Aminet 1/Aminet - June 1993 [Walnut Creek].iso/usenet/sources/volume90/util/popupmen/part03

Internet Message Format | 1990-04-14 | 15.1 KB

Path: wuarchive!zaphod.mps.ohio-state.edu!uakari.primate.wisc.edu!xanth!cs.odu.edu!Amiga-Request
From: [e-mail] (Amiga Sources/Binaries Moderator)
Newsgroups: comp.sources.amiga
Subject: v90i137: PopUpMenu 3.2 - make intuition menus into pop up menus, Part03/03
Message-ID: <[e-mail]>
Date: 13 Apr 90 23:46:20 GMT
Sender: [e-mail]
Reply-To: [e-mail] (Martin Adrian)
Lines: 499
Approved: [e-mail] (Tad Guy)
X-Mail-Submissions-To: [e-mail]
X-Post-Discussions-To: comp.sys.amiga

Submitted-by: [e-mail] (Martin Adrian)
Posting-number: Volume 90, Issue 137
Archive-name: util/popupmenu-3.2/part03

#!/bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#        "End of archive 3 (of 3)."
# Contents:  Source/OpenWindows.c
# Wrapped by tadguy@xanth on Fri Apr 13 19:45:21 1990
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'Source/OpenWindows.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'Source/OpenWindows.c'\"
else
echo shar: Extracting \"'Source/OpenWindows.c'\" \(12815 characters\)
sed "s/^X//" >'Source/OpenWindows.c' <<'END_OF_FILE'
X#include "PopUpMenu.h"
X
X/* these must be declared here in this silly way (lattice 5.0 bug) */
XIMPORT UWORD  chip GhostPattern[];
XIMPORT WORD   far  NormalPattern[];
XIMPORT struct Image chip MyAmigaKeyImage[];
XIMPORT struct Image far MySubItemImage[];
X
X
X/****************************************
X * OpenMenuWindow()                     *
X *                    *
X * Input:                *
X *   none                *
X * Output:                *
X *   return    - TRUE if window opened. *
X ****************************************/
X
XBOOL OpenMenuWindow(MenuTop)
X  WORD MenuTop;
X{
X/*
X  IMPORT UWORD far GhostPattern[2];
X  IMPORT UWORD far NormalPattern[2];
X*/
X  IMPORT struct Window    *const ActiveWindow;
X  IMPORT struct Menu    *const Menues;
X  IMPORT struct Screen    *const Screen;
X  IMPORT struct RastPort      Rp;     /* Screens RastPort */
X  IMPORT struct WindowData    MenuWindow;
X  IMPORT const UWORD         MenuFontSize;
X
X  WORD    MenuWidth     = 0;
X  WORD    MenuHeight    = BORDERSIZE + 1;
X
X /****************************************
X  * Find width & height of window needed *
X  ****************************************/
X  {
X    struct Menu *MenuPtr = Menues;
X
X    do {
X      UWORD Length;
X
X      Length = TextLength(&Rp,MenuPtr->MenuName,Mystrlen(MenuPtr->MenuName));
X      if (MenuPtr->Width > Length)
X    Length = MenuPtr->Width;
X      if (Length > MenuWidth)
X    MenuWidth = Length;
X      MenuHeight += MenuFontSize;
X    }
X    while ((MenuPtr = MenuPtr->NextMenu) != NULL);
X
X    MenuWidth  += (2 * BORDERSIZE + 1);
X  }
X /************************************
X  * Position window on screen (Left) *
X  ************************************/
X  {
X    WORD MenuLeft = Screen->MouseX - ((UWORD)MenuWidth / 2);
X
X    if (MenuLeft < 0)
X      MenuLeft = 0;
X    if (MenuLeft + MenuWidth > Screen->Width)
X      MenuLeft = Screen->Width - MenuWidth;
X
X    MenuWindow.LeftEdge  = MenuLeft;
X    MenuWindow.Width     = MenuWidth;
X  }
X /***********************************
X  * Position window on screen (Top) *
X  ***********************************/
X  {
X    if (MenuTop > MenuHeight) /* menues has changed */
X      MenuTop = 0;
X    MenuTop  = Screen->MouseY - (MenuFontSize / 2) - MenuTop;
X
X    if (MenuTop < 0)
X      MenuTop = 0;
X    if (MenuTop + MenuHeight > Screen->Height)
X      MenuTop = Screen->Height - MenuHeight;
X
X    MenuWindow.TopEdge     = MenuTop;
X    MenuWindow.Height     = MenuHeight;
X  }
X /*******************************
X  * Open window with right size *
X  *******************************/
X
X  if (BuildBitMap(&MenuWindow) == FALSE)
X    return (FALSE);
X
X /**********************
X  * Fill in all menues *
X  **********************/
X  {
X    const LONG     MenuLeft = MenuWindow.LeftEdge + BORDERSIZE;
X    struct Menu *MenuPtr  = Menues;
X
X    do {
X      MenuTop += MenuFontSize;
X
X      SetAPen(&Rp,(LONG)ActiveWindow->DetailPen);
X      Move(&Rp,MenuLeft,(LONG)MenuTop - 1);
X      Text(&Rp,MenuPtr->MenuName,Mystrlen(MenuPtr->MenuName));
X
X      /* Ghostitem ? */
X      if (NOT (MenuPtr->Flags & MENUENABLED)) {
X    SetAfPt(&Rp, GhostPattern, 1);
X    SetAPen(&Rp,(LONG)ActiveWindow->BlockPen);
X    RectFill(&Rp,MenuLeft,
X             (LONG)(MenuTop - MenuFontSize + BORDERSIZE),
X             (LONG)(MenuWindow.RightEdge - BORDERSIZE),
X             (LONG)MenuTop);
X    SetAfPt(&Rp,NormalPattern,1);
X      }
X    }
X    while ((MenuPtr = MenuPtr->NextMenu) != NULL);
X  }
X
X  return (TRUE);
X}
X
X/**************************************************************
X * OpenItemWindow(ItemWindow,ParentWindow,TopPos,WindowType)  *
X *                                  *
X * Input:                              *
X *   ItemWindow   - Window to open.                  *
X *   ParentWindow -                          *
X *   TopPos      - Top position for new window.          *
X *   WindowType   - ITEMWINDOW or SUBWINDOW              *
X * Output:                              *
X *   none                              *
X **************************************************************/
XVOID OpenItemWindow(ItemWindow,ParentWindow,TopPos,WindowType)
X  struct WindowData  *const ItemWindow;
X  struct WindowData  *const ParentWindow;
X  const WORD TopPos;
X  const UWORD WindowType;
X{
X  IMPORT struct Screen       *const Screen;
X  IMPORT struct WindowData  MenuWindow;
X  IMPORT const WORD  MouseX;
X
X  struct WindowSize  Size;
X
X /****************************************
X  * Find width & height of window needed *
X  ****************************************/
X  {
X    struct MenuItem  *Item = ItemWindow->Items;
X
X    Size.Left  = WORD_MAX;
X    Size.Top   = WindowType; /* (ITEMWINDOW -> TopPos >= 0), SUBWINDOW -> no limit */
X    Size.Right = Size.Bottom = WORD_MIN;
X
X    do {
X      CheckItemSize(&Size,Item,(LONG)Item->ItemFill);
X      if ((Item->Flags & HIGHFLAGS) == HIGHIMAGE)
X    CheckItemSize(&Size,Item,(LONG)Item->SelectFill); /* check highlighted */
X    }
X    while (Item = Item->NextItem);
X  }
X /**********************************************
X  * Position window on screen (left)           *
X  * Possible positions:                *
X  *   1. At real position (a'la intuition).    *
X  *   2. At right side of parent.           *
X  *   3. At left side of parent.           *
X  *   4. On the side that covers parent least. *
X  **********************************************/
X  {
X    WORD  WindowLeft;
X    WORD  LeftValue   = Size.Left - BORDERSIZE;
X    UWORD WindowWidth = Size.Right - LeftValue + BORDERSIZE;
X    WORD  LeftPos2    = ParentWindow->LeftEdge - WindowWidth + 7;
X    WORD  MaxLeft     = Screen->Width - WindowWidth;
X
X    if ((WindowType == ITEMWINDOW) OR
X    ((WindowLeft = ParentWindow->LeftEdge + LeftValue) > MaxLeft) OR
X    (WindowLeft < 0))
X      WindowLeft = ParentWindow->RightEdge - 7;
X
X    if (WindowLeft > MaxLeft)
X      if (LeftPos2 > MaxLeft - WindowLeft)
X    WindowLeft = (LeftPos2 > 0) ? LeftPos2 : 0;
X      else
X    WindowLeft = MaxLeft;
X
X    if (WindowLeft + WindowWidth < ParentWindow->LeftEdge + 7)
X      WindowWidth = ParentWindow->LeftEdge + 7 - WindowLeft;
X
X    ItemWindow->LeftEdge  = WindowLeft;
X    ItemWindow->LeftValue = LeftValue - WindowLeft;
X    ItemWindow->Width      = WindowWidth;
X  }
X /***********************************
X  * Position Window on screen (Top) *
X  ***********************************/
X  {
X    WORD  TopValue     = Size.Top - BORDERSIZE;
X    WORD  WindowTop    = TopPos + TopValue;
X    UWORD WindowHeight = Size.Bottom - TopValue  + BORDERSIZE;
X
X    if (WindowTop + WindowHeight > Screen->Height)
X      WindowTop = Screen->Height - WindowHeight;
X    if (WindowTop < 0)
X      WindowTop = 0;
X
X    ItemWindow->TopEdge   = WindowTop;
X    ItemWindow->TopValue  = TopValue - WindowTop;
X    ItemWindow->Height      = WindowHeight;
X  }
X
X  if (BuildBitMap(ItemWindow) == FALSE)
X    return;
X
X  DrawAllItems(ItemWindow);
X}
X
X/****************************************
X * DrawAllItems(ItemWindow)             *
X *                    *
X * Input:                *
X *   ItemWindow  - Window to draw into. *
X *                    *
X * Output                *
X *   none                *
X ****************************************/
XVOID DrawAllItems(ItemWindow)
X  struct WindowData *const ItemWindow;
X{
X  struct MenuItem *Item = ItemWindow->Items;
X
X  ClearWindow(ItemWindow);
X
X  do
X    DrawMenuItem(Item, ItemWindow, ITEMFILL, DONTCLEAROLD);
X  while ((Item = Item->NextItem) != NULL);
X}
X
X/****************************************************************************
X * DrawMenuItem(Item, ItemWindow, Mode, Clear)                              *
X *                                        *
X * Input:                                    *
X *   Item -      Item to draw.                         *
X *   ItemWindow - Data about window to draw item into                *
X *   Mode -      ITEMFILL = Draw Item                        *
X *          SELECTFILL = Draw selected item (if any)                  *
X *   Clear -      Clear position before drawing  (Only used with HighImage) *
X * OUTPUT                                    *
X *   none                                    *
X ****************************************************************************/
X
XVOID DrawMenuItem(Item,ItemWindow,Mode,Clear)
X  struct MenuItem *const Item;
X  struct WindowData  *const ItemWindow;
X  const UWORD Mode;
X  const BOOL   Clear;
X{
X/*
X  IMPORT UWORD far GhostPattern[2];
X  IMPORT UWORD far NormalPattern[2];
X  IMPORT struct Image far MyAmigaKeyImage[2];
X  IMPORT struct Image far MySubItemImage[2];
X*/
X
X  IMPORT struct RastPort Rp;
X  IMPORT struct Window    *const ActiveWindow;
X  IMPORT struct Screen    *const Screen;
X  IMPORT const BOOL  ScreenType;
X
X  union FillTypes Fill;
X  const LONG Left = Item->LeftEdge - ItemWindow->LeftValue;
X  const LONG Right = Left + Item->Width - 1;
X  const LONG Top = Item->TopEdge - ItemWindow->TopValue;
X  const LONG Bottom = Top + Item->Height - 1;
X
X  /* Find what to Draw */
X  if (!(Fill.APTR = (Mode == SELECTFILL) ? Item->SelectFill : Item->ItemFill))
X    return;  /* nothing to draw */
X
X  SetAPen(&Rp, (LONG)(ActiveWindow->BlockPen));
X  SetDrMd(&Rp, JAM1);
X
X  if (Clear)
X    /* Erase whay may already be here */
X    RectFill(&Rp, Left, Top, Right, Bottom);
X
X  /* Now, draw the item itself -- depending on the Flag value, it    */
X  /* could be either an Image or an IntuiText */
X
X  if (Item->Flags & ITEMTEXT)
X    PrintIText(&Rp, Fill.IText, Left, Top);
X  else
X    DrawImage(&Rp,  Fill.Image, Left, Top);
X
X  /* If the item is checkmarked, draw the checkmark. */
X
X  if ((Item->Flags & (CHECKIT | CHECKED)) == (CHECKIT | CHECKED))
X    DrawImage(&Rp, ActiveWindow->CheckMark, Left, Top);
X
X  /* If the item has a commandkey, or a subitem */
X  {
X    const LONG ItemTop    = Top + ((Item->Flags & ITEMTEXT) ?
X                     Fill.IText->TopEdge:
X                     Fill.Image->TopEdge);
X
X    if (Item->Flags & COMMSEQ) {
X      const LONG KeyLeft = Right - Rp.TxWidth;
X
X      DrawImage(&Rp, &MyAmigaKeyImage[ScreenType],KeyLeft, ItemTop);
X
X      Move(&Rp, KeyLeft, ItemTop + Rp.TxHeight - 2);
X      SetAPen(&Rp, (LONG)(ActiveWindow->DetailPen));
X      Text(&Rp,&Item->Command,1);
X    }
X
X    if (Item->SubItem)
X      DrawImage(&Rp,&MySubItemImage[ScreenType],Right,ItemTop);
X  }
X
X  /* If the ITEMENABLED flag is not set, "ghost" the item. */
X
X  if (!(Item->Flags & ITEMENABLED)) {
X    SetAfPt(&Rp, GhostPattern, 1);
X    SetAPen(&Rp, (LONG)(ActiveWindow->BlockPen));
X    RectFill(&Rp, Left, Top, Right, Bottom);
X    SetAfPt(&Rp, NormalPattern, 1);
X  }
X}
X
X/****************************************
X * BuildBitMap(Window)  - OpenWindow    *
X *                    *
X * Input:                *
X *   Window    - Window to open.    *
X * Output:                *
X *   return    - TRUE if window opened. *
X ****************************************/
XBOOL BuildBitMap(Window)
X  struct WindowData *const Window;
X{
X  IMPORT struct Screen     *const Screen;
X  IMPORT struct RastPort Rp;
X
X  const LONG WindowWidth  = Window->Width;
X  const LONG WindowHeight = Window->Height;
X
X  /* is window to big for screen ? */
X
X  if ((WindowWidth > Screen->Width) OR
X      (WindowHeight > Screen->Height))
X    return (FALSE);
X
X  Window->RightEdge = Window->LeftEdge + WindowWidth  - 1;
X  Window->Bottom    = Window->TopEdge  + WindowHeight - 1;
X
X  /* init bitmap */
X  {
X    const ULONG Depth = Screen->BitMap.Depth;
X    UWORD i;
X
X    InitBitMap(&Window->Bm,Depth,WindowWidth,WindowHeight);
X
X    /* allocate raster for all bitplanes */
X
X    for (i = 0; i < Depth; i++)
X      if ((Window->Bm.Planes[i] = AllocRaster(WindowWidth,WindowHeight)) == NULL) {
X    RemoveBitMap(Window);
X    return(FALSE);
X      }
X  }
X
X  Window->BitMapOk = TRUE;
X
X  /* make window visible */
X  SwapBits(Window);
X
X  ClearWindow(Window);
X
X  return (TRUE);
X}
X
X/*********************************
X * ClearWindow(window)           *
X *                 *
X * Input:             *
X *   Window   - Window to clear. *
X * OutPut:             *
X *   none             *
X *********************************/
XVOID ClearWindow(Window)
X  struct WindowData *const Window;
X{
X  IMPORT struct RastPort Rp;
X  IMPORT struct Window *const ActiveWindow;
X
X  /* window should look like intuitionmenues */
X  SetDrMd(&Rp, JAM1);
X
X  SetAPen(&Rp,(LONG)ActiveWindow->BlockPen);
X  SetOPen(&Rp,(LONG)ActiveWindow->DetailPen);
X
X  RectFill(&Rp,(LONG)Window->LeftEdge,
X           (LONG)Window->TopEdge,
X           (LONG)Window->RightEdge,
X           (LONG)Window->Bottom);
X  BNDRYOFF(&Rp);
X}
X
X/******************************
X * CloseItemWindow(Window)    *
X *                  *
X *INPUT               *
X *  Window - Window to close. *
X *OUTPUT              *
X *  none              *
X ******************************/
XVOID CloseItemWindow(Window)
X  struct WindowData *const Window;
X{
X  if (Window->BitMapOk) {
X    /* remove window from screen */
X    SwapBits(Window);
X
X    /* remove all bitplanes */
X    RemoveBitMap(Window);
X  }
X}
X
X/****************************************************************************
X * RemoveBitMap(Window) - Remove allocated rasters in the BitMap structure. *
X *                                        *
X * Input:                                    *
X *   Window   - Window with bitmap-                        *
X * Output:                                    *
X *   none                                    *
X ****************************************************************************/
XVOID RemoveBitMap(Window)
X  struct WindowData *const Window;
X{
X  struct BitMap *const Bm = &Window->Bm;
X  UWORD  i;
X
X  /* remove all allocated rasters */
X  for (i = 0; i < Bm->Depth; i++)
X    if (Bm->Planes[i])
X      FreeRaster(Bm->Planes[i],(LONG)Window->Width,(LONG)Window->Height);
X
X  Window->BitMapOk = FALSE;
X}
X
END_OF_FILE
if test 12815 -ne `wc -c <'Source/OpenWindows.c'`; then
    echo shar: \"'Source/OpenWindows.c'\" unpacked with wrong size!
fi
# end of 'Source/OpenWindows.c'
fi
echo shar: End of archive 3 \(of 3\).
cp /dev/null ark3isdone
MISSING=""
for I in 1 2 3 ; do
    if test ! -f ark${I}isdone ; then
    MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 3 archives.
    rm -f ark[1-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0
--
Mail submissions (sources or binaries) to <[e-mail]>.
Mail comments to the moderator at <[e-mail]>.
Post requests for sources, and general discussion to comp.sys.amiga.